#include "AffichageSdl.h"

#include <stdlib.h>
#include <assert.h>

#include <SDL/SDL_image.h>
#include <SDL/SDL_rotozoom.h>
#include <time.h>
#include <unistd.h>


AffichageSdl * creerAffichageSdl()
{
    AffichageSdl *unAffichageSdl = (AffichageSdl *)malloc(sizeof(AffichageSdl));
    initAffichageSdl(unAffichageSdl);
    return unAffichageSdl;
}
void initAffichageSdl(AffichageSdl *unAffichageSdl)
{
   const SDL_VideoInfo* myPointer;
    SDL_Surface *temp;
    int x,  y, tailleW, tailleX, tailleY;
    double rapport;
    /* Initialise SDL et le sous-système vidéo*/
    assert(SDL_Init(SDL_INIT_VIDEO) != -1);
    assert(TTF_Init() != -1);

    /*Récupère les informations sur le matériel vidéo actuel*/
    myPointer = SDL_GetVideoInfo();
    assert(myPointer != NULL);

    /* Creer écran et Configure le mode vidéo*/
    unAffichageSdl->ecran = SDL_SetVideoMode(myPointer->current_w, myPointer->current_h, /*myPointer->vfmt->BitsPerPixel*/32,  SDL_HWSURFACE|SDL_DOUBLEBUF|SDL_FULLSCREEN);
    assert(unAffichageSdl->ecran != NULL);
    SDL_FillRect(unAffichageSdl->ecran, NULL, SDL_MapRGB(unAffichageSdl->ecran->format, 255, 255, 255));
    /*setVariablesGlobales(variable, "FORMATECRAN", (int)ecran->format);*/
    unAffichageSdl->tailleXEcran = (int)(myPointer->current_w);
    unAffichageSdl->tailleYEcran = (int)(myPointer->current_h);
    unAffichageSdl->tailleCase = (int)((myPointer->current_h-40)/6);


    x = 6 * unAffichageSdl->tailleCase;
    y = 6 * unAffichageSdl->tailleCase;
    tailleX = unAffichageSdl->tailleXEcran;
    tailleY = unAffichageSdl->tailleYEcran;

	unAffichageSdl->SurfacePlateau = SDL_CreateRGBSurface(SDL_HWSURFACE, x, y, 32,0,0,0,0);
	assert(unAffichageSdl->SurfacePlateau != NULL);

	unAffichageSdl->SurfaceScore = SDL_CreateRGBSurface(SDL_HWSURFACE, tailleX-tailleY, tailleY, 32,0,0,0,0);
	assert(unAffichageSdl->SurfaceScore != NULL);

    LoadAll(unAffichageSdl); /*charge le tableau d'image */
    unAffichageSdl->affTableau = false;
    unAffichageSdl->affCarte = false;

    temp = IMG_Load("data/image/tableau.jpg");
    tailleW = temp->w;
    rapport = (double)tailleW/(double)(tailleY-40);
    if(rapport>1)
        rapport = 1/rapport;
    unAffichageSdl->SurfaceTableau = rotozoomSurface(temp, 0.0, rapport, 1);


    temp = IMG_Load("data/image/plateau.png");
    tailleW = temp->w;
    rapport = (double)tailleW/(double)(tailleY-40);
    if(rapport>1)
        rapport = 1/rapport;
    unAffichageSdl->surfaceCases = rotozoomSurface(temp, 0.0, rapport, 1);

    free(temp);

    unAffichageSdl->piocheCarte = NULL;

    unAffichageSdl->phraseEtat = malloc(sizeof(char)*64);
}
void libereAffichageSdl(AffichageSdl *unAffichageSdl)
{
    int i;
    SDL_FreeSurface(unAffichageSdl->SurfacePlateau);
    SDL_FreeSurface(unAffichageSdl->SurfaceScore);
    SDL_FreeSurface(unAffichageSdl->SurfaceTableau);

    for(i=0;i<unAffichageSdl->nbImgPion;i++)
        SDL_FreeSurface(unAffichageSdl->imagesPion[i]);
    free(unAffichageSdl->imagesPion);
    for(i=0;i<unAffichageSdl->nbImgCarte;i++)
        SDL_FreeSurface(unAffichageSdl->imagesCarte[i]);
    free(unAffichageSdl->imagesCarte);
    for(i=0;i<unAffichageSdl->nbImgCarte-2;i++)
        SDL_FreeSurface(unAffichageSdl->imagesCarteMini[i]);
    free(unAffichageSdl->imagesCarteMini);

    unAffichageSdl->affTableau = false;
    unAffichageSdl->affCarte = false;

    unAffichageSdl->piocheCarte = NULL;

    free(unAffichageSdl->phraseEtat);

    SDL_FreeSurface(unAffichageSdl->ecran);
    TTF_Quit();
    SDL_Quit();
}
void detruitAffichageSdl(AffichageSdl **unAffichageSdl)
{
    libereAffichageSdl(*unAffichageSdl);
    free(*unAffichageSdl);
    *unAffichageSdl = NULL;
}

/*CHARGEMENT D'IMAGE*/
void LoadAll(AffichageSdl *affichageSdl)
{
    int tailleY = affichageSdl->tailleYEcran;
    int tailleW;
    double rapport;

    int i;
    char* allPion[] = {"data/image/pionRouge.png","data/image/pionBleu.png","data/image/pionVert.png","data/image/pionJaune.png"};
    char* allCarte[] = {"data/image/carteMain.png","data/image/carteVide.jpeg","data/image/carte1.jpeg","data/image/carte2.jpeg","data/image/carte3.jpeg","data/image/carte4.jpeg","data/image/carte5.jpeg","data/image/carte6.jpeg","data/image/carte7.jpeg"};

    affichageSdl->nbImgPion = sizeof(allPion)/sizeof(char*);
    affichageSdl->nbImgCarte = sizeof(allCarte)/sizeof(char*);

    affichageSdl->imagesPion = malloc(affichageSdl->nbImgPion*sizeof(SDL_Surface*));
    affichageSdl->imagesCarte = malloc(affichageSdl->nbImgCarte*sizeof(SDL_Surface*));
    affichageSdl->imagesCarteMini = malloc((affichageSdl->nbImgCarte-2)*sizeof(SDL_Surface*));

    for(i=0;i<affichageSdl->nbImgPion;i++)
    {
        affichageSdl->imagesPion[i] = IMG_Load(allPion[i]);
    }
    for(i=0;i<affichageSdl->nbImgCarte;i++)
    {
       affichageSdl->imagesCarte[i] = IMG_Load(allCarte[i]);
    }
    for(i=0;i<affichageSdl->nbImgCarte-2;i++)
    {
        tailleW = affichageSdl->imagesCarte[i+2]->h;
        rapport = (double)tailleW/(double)(tailleY-40);
       affichageSdl->imagesCarteMini[i] = rotozoomSurface(affichageSdl->imagesCarte[i+2], 0.0, rapport, 1);
    }
}

/*BOUCLE PRINCIPALE*/
void affichageBoucle()
{
    AffichageSdl * aff = creerAffichageSdl();
    unsigned int elapsed;
    unsigned int lasttime;

    int nbrJ=4, nbrPlat=2;
    /*debutPartie(aff, &nbrJ, &nbrPlat);*/

    Jeu *jeu = creerJeu(nbrJ, nbrPlat);

    Input in;
    memset(&in,0,sizeof(in));  /*initialisation de tous les champs à 0*/

    srand((unsigned int)time(NULL));
    while(!in.key[SDLK_ESCAPE] && jeu->etatJeu != 5) /*Tant qu'on ne quitte pas ou fin de partie*/
    {
        lasttime = SDL_GetTicks();

        gestionEvents(&in);
        evolutionJeu(aff, &in, jeu);
        affichageJeu(aff, jeu);

        while(SDL_Flip(aff->ecran)!=0)
            SDL_Delay(1);
        elapsed = SDL_GetTicks()-lasttime;
        if (elapsed<20)
            SDL_Delay(20-elapsed);
    }

    detruitAffichageSdl(&aff);
    detruitJeu(&jeu);
}

/*GESTION DES EVENEMENTS*/
void gestionEvents(Input* in)
{
    SDL_Event event;

    /*Gestion de la molette*/
    in->mousebuttons[SDL_BUTTON_WHEELUP] = 0;
    in->mousebuttons[SDL_BUTTON_WHEELDOWN] = 0;

    while(SDL_PollEvent(&event))
    {
        switch (event.type)
        {
        case SDL_KEYDOWN:
            in->key[event.key.keysym.sym]=1;
            break;
        case SDL_KEYUP:
            in->key[event.key.keysym.sym]=0;
            break;
        case SDL_MOUSEMOTION:
            in->mousex=event.motion.x;
            in->mousey=event.motion.y;
            break;
        case SDL_MOUSEBUTTONDOWN:
            in->mousebuttons[event.button.button]=1;
            break;
        case SDL_MOUSEBUTTONUP:
            if (event.button.button!=SDL_BUTTON_WHEELUP && event.button.button!=SDL_BUTTON_WHEELDOWN)
                in->mousebuttons[event.button.button]=0;
            break;
        default:
            break;
        }
    }
}
void evolutionJeu(AffichageSdl *aff, Input *in, Jeu *jeu)
{
    int k=0;
    int jouAct = jeu->joueurActu;
    int posJou = getPosition(jeu->jou[jouAct]);
    int niveau = jeu->jou[jouAct]->niveauJoueur;
    int nbBonus = jeu->jou[jouAct]->nbMainJoueur;
    int tailleX = aff->tailleXEcran;
    int tailleY = aff->tailleYEcran;
    int x = in->mousex;
    int y = in->mousey;
    bool questionValide = false;

    switch(jeu->etatJeu)
    {
        case 0: /*test possiblilités joueurs*/
            if(get_etat(jeu->jou[jouAct]) == 1)
            {
                sprintf(aff->phraseEtat,"GEEK %d : TU PEUX JOUER!", jouAct+1);
                jeu->etatJeu = 1;
            }
            else
            {
                sprintf(aff->phraseEtat,"GEEK %d : PASSE TON TOUR!  --> V", jouAct+1);
                set_etat(jeu->jou[jouAct],1);
                jeu->etatJeu = 4;
            }
            break;


        case 1: /*attente de lancer de dés*/
            sprintf(aff->phraseEtat,"GEEK %d : LANCE LE DÉ --> D  ou utilise  une carte jouer 2 fois", jouAct+1);
            if(in->key[SDLK_d] /* || souris sur dés*/)
            {
                in->key[SDLK_d] = 0;
                joueurUnTour(jeu);
                jeu->etatJeu = 2;
            }
            if(in->mousebuttons[SDL_BUTTON_LEFT])
            {
                if(nbBonus>0)
                {
                    in->mousebuttons[SDL_BUTTON_LEFT] = 0;
                    if((x>tailleX-100)&&(x<tailleX))
                    {
                        if(y>0 && y<tailleY/4)
                            k=0;
                        else if(y>tailleY/4 && y<tailleY/2)
                            k=1;
                        else if(y>tailleY/2 && y<tailleY/4*3)
                            k=2;
                        else if(y>tailleY/4*3 && y<tailleY)
                            k=3;

                        if(jeu->jou[jouAct]->mainJoueur[k] != NULL)
                        {
                            if(getGenreCarte(jeu->jou[jouAct]->mainJoueur[k]) == sandwich)
                            {
                                joueurUnTour(jeu);
                                enleverCarteMain(jeu->jou[jouAct], k);
                                jeu->etatJeu = 1;
                            }
                        }
                    }
                }
            }
            break;

        case 2:
            if(posJou == 35)
            {
                if(bilanJoueur(jeu))
                {
                    sprintf(aff->phraseEtat,"GEEK %d : TU GAGNES!", jouAct+1);
                    jeu->etatJeu = 5;
                    printf("Joueur %d Gagne!", jouAct+1);
                }
                else
                    jeu->etatJeu = 4;
            }
            else
                jeu->etatJeu = 3;
            break;

        case 3:
            switch(getGenreCase (get_case(jeu->plateaux[niveau],getPosition(jeu->jou[jouAct]))))
            {
                case exam:
                    if(getValideCase (get_case(jeu->plateaux[niveau],posJou), jouAct) == true)
                    {
                        sprintf(aff->phraseEtat,"GEEK %d : CASE DEJA VALIDÉE, RELANCE LE DÉ!", jouAct+1);

                        jeu->etatJeu = 1;
                    }
                    else
                    {
                        sprintf(aff->phraseEtat,"GEEK %d : EXAMEN!  CLIQUE SUR LA BONNE REPONSE... OU TRICHE!", jouAct+1);
                        aff->affTableau = true;

                        if(in->mousebuttons[SDL_BUTTON_LEFT])
                        {
                            if(y>aff->posBonneRep+10 && y<(aff->posBonneRep+40) && x>0 && x<tailleY)
                            {
                                in->mousebuttons[SDL_BUTTON_LEFT] = 0;
                                questionValide = true;
                                setValideCase (get_case(jeu->plateaux[niveau],posJou), jouAct, 1);
                                setScore(jeu->jou[jouAct],(getScore(jeu->jou[jouAct])+1));
                            }
                            else if(x>0 && x<tailleY && y>0 && y<tailleY)
                            {
                                in->mousebuttons[SDL_BUTTON_LEFT] = 0;
                                questionValide = true;
                            }
                            else if(nbBonus>0)
                            {
                                in->mousebuttons[SDL_BUTTON_LEFT] = 0;
                                if((x>tailleX-100)&&(x<tailleX))
                                {
                                    if(y>0 && y<tailleY/4)
                                        k=0;
                                    else if(y>tailleY/4 && y<tailleY/2)
                                        k=1;
                                    else if(y>tailleY/2 && y<tailleY/4*3)
                                        k=2;
                                    else if(y>tailleY/4*3 && y<tailleY)
                                        k=3;

                                    if(jeu->jou[jouAct]->mainJoueur[k] != NULL)
                                    {
                                        if(getGenreCarte(jeu->jou[jouAct]->mainJoueur[k]) == reponse)
                                        {
                                            questionValide = true;
                                            setValideCase (get_case(jeu->plateaux[niveau],posJou), jouAct, 1);
                                            setScore(jeu->jou[jouAct],(getScore(jeu->jou[jouAct])+1));
                                            enleverCarteMain(jeu->jou[jouAct], k);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    if(questionValide)
                    {
                        aff->affTableau = false;
                        questionValide = false;
                        jeu->etatJeu = 4;
                    }
                    break;

                case pioche:
                    sprintf(aff->phraseEtat,"GEEK %d : PIOCHE! POUR VALIDER  --> V", jouAct+1);
                    aff->piocheCarte = retourneTetePioche(jeu->pioche);
                    aff->affCarte = true;

                    if(in->key[SDLK_v])
                    {
                        in->key[SDLK_v] = 0;
                        consequenceCarteJoueur(aff->piocheCarte, jeu->jou[jouAct]);
                        aff->affCarte = false;
                        defilerRenfilerCarte(jeu->pioche);
                        aff->piocheCarte = NULL;
                        jeu->etatJeu = 2;
                    }
                    break;

                case bonus:
                    switch(getPosition(jeu->jou[jouAct]))
                    {
                        case 7:
                            sprintf(aff->phraseEtat,"GEEK %d : TU ES AU RU! POUR VALIDER  --> V", jouAct+1);
                            aff->piocheCarte = retourneTetePioche(jeu->bonusRU);
                            break;
                        case 14:
                            sprintf(aff->phraseEtat,"GEEK %d : TU ES A LA BU! POUR VALIDER  --> V", jouAct+1);
                            aff->piocheCarte = retourneTetePioche(jeu->bonusBU);
                            break;
                        case 21:
                            sprintf(aff->phraseEtat,"GEEK %d : TU ES AU CYBER! POUR VALIDER  --> V", jouAct+1);
                            aff->piocheCarte = retourneTetePioche(jeu->bonusCYBER);
                            break;
                        case 28:
                            sprintf(aff->phraseEtat,"GEEK %d : TU ES UN TRICHEUR! POUR VALIDER  --> V", jouAct+1);
                            aff->piocheCarte = retourneTetePioche(jeu->bonusTRICHE);
                            break;
                        default:
                            sprintf(aff->phraseEtat,"GEEK %d : ERREUR SWITCH! POUR VALIDER  --> V", jouAct+1);
                            aff->piocheCarte = retourneTetePioche(jeu->bonusBU);
                    }

                    aff->affCarte = true;

                    if(in->key[SDLK_v])
                    {
                        in->key[SDLK_v] = 0;
                        aff->affCarte = false;

                        switch(getPosition(jeu->jou[jouAct]))
                        {
                            case 7:
                                defilerRenfilerCarte(jeu->bonusRU);
                                break;
                            case 14:
                                defilerRenfilerCarte(jeu->bonusBU);
                                break;
                            case 21:
                                defilerRenfilerCarte(jeu->bonusCYBER);
                                break;
                            case 28:
                                defilerRenfilerCarte(jeu->bonusTRICHE);
                                break;
                            default:
                                defilerRenfilerCarte(jeu->bonusBU);
                        }
                        consequenceCarteJoueur(aff->piocheCarte, jeu->jou[jouAct]);
                        aff->piocheCarte = NULL;
                        jeu->etatJeu = 4;
                    }
                    break;

                default:
                    jeu->etatJeu = 4;
                    break;
            }
            break;

        case 4: /*passage joueurSuivant*/
            joueurSuivant(jeu);
            jeu->etatJeu = 0;

            break;
        default:
            break;
    }
}

/*FONCTION D'AFFICHAGE*/
void affichageJeu(AffichageSdl *affichageSdl, const Jeu *unJeu)
{
    SDL_Rect positionSurfacePlateau;
    SDL_Rect positionSurfaceScore;

    positionSurfacePlateau.x=20;
    positionSurfacePlateau.y=20;
    positionSurfaceScore.x=affichageSdl->tailleYEcran;
    positionSurfaceScore.y=0;

    SDL_FillRect(affichageSdl->ecran,NULL,SDL_MapRGB(affichageSdl->ecran->format, 255,255,255));

	affichageSurfacePlateau(affichageSdl, unJeu);
    affichageSurfaceScore(affichageSdl, unJeu);
	affichageTousJoueurs(affichageSdl, unJeu);
	affichageEtatJeu(affichageSdl, unJeu);
	affichageMainJoueur(affichageSdl, unJeu);

	if(affichageSdl->affTableau)
	{
	    affichageQuestion(affichageSdl, unJeu);
	}
    if(affichageSdl->affCarte)
	{
	    affichageCarte(affichageSdl, unJeu);
	}

    SDL_BlitSurface(affichageSdl->SurfaceScore, NULL, affichageSdl->ecran, &positionSurfaceScore);
    SDL_BlitSurface(affichageSdl->SurfacePlateau, NULL, affichageSdl->ecran, &positionSurfacePlateau);
}

void affichageEtatJeu(AffichageSdl *aff, const Jeu *jeu)
{
    SDL_Rect pos;
    /*char *phrase = malloc(sizeof(char)*128);*/
    /*char *phrase2 = malloc(sizeof(char)*128);*/

    SDL_Color couleur = {0,0,0};
    aff->police = TTF_OpenFont("data/police.ttf", 17);

    pos.x = 50;
    pos.y = 3;
    /*sprintf(phrase, "Etat du Jeu: %s :", phrase2);*/
    aff->texte = TTF_RenderUTF8_Blended(aff->police, aff->phraseEtat, couleur);
    SDL_BlitSurface(aff->texte, NULL, aff->ecran, &pos);
    SDL_FreeSurface(aff->texte);

    /*free(phrase);*/
    TTF_CloseFont(aff->police);
}
void affichageCarte(AffichageSdl *aff, const Jeu *jeu)
{
    SDL_Rect pos;
    char *phrase = malloc(sizeof(char)*128);
    SDL_Color couleur = {0,0,0};
    aff->police = TTF_OpenFont("data/police.ttf", 18);

    pos.x = 150;
    pos.y = 100;

    SDL_BlitSurface(aff->imagesCarte[aff->piocheCarte->genre+1], NULL, aff->SurfacePlateau, &pos);

    pos.x = 180;
    pos.y = 110;
    sprintf(phrase, "%s :", aff->piocheCarte->nom);
    aff->texte = TTF_RenderUTF8_Blended(aff->police, phrase, couleur);
    SDL_BlitSurface(aff->texte, NULL, aff->SurfacePlateau, &pos);
    SDL_FreeSurface(aff->texte);

    free(phrase);
    TTF_CloseFont(aff->police);
}
void affichageQuestion(AffichageSdl *aff, const Jeu *jeu)
{
    SDL_Rect pos;
    char *phrase = malloc(sizeof(char)*128);
    SDL_Color couleur = {255,255,255};
    int i;
    int act = jeu->joueurActu;
    int niveau = jeu->jou[act]->niveauJoueur;
    int position = getPosition(jeu->jou[act]);
    Question * question = getActionCase(get_case(jeu->plateaux[niveau],position));
    aff->police = TTF_OpenFont("data/police.ttf", 15);

    pos.x = 0;
    pos.y = 0;
    SDL_BlitSurface(aff->SurfaceTableau, NULL, aff->SurfacePlateau, &pos);

        pos.x = 45;
        pos.y = 40;
        sprintf(phrase, "%s :", question->Quest);
        aff->texte = TTF_RenderUTF8_Blended(aff->police, phrase, couleur);
        SDL_BlitSurface(aff->texte, NULL, aff->SurfacePlateau, &pos);
        SDL_FreeSurface(aff->texte);

        for(i=0;i<4;i++)
        {
            pos.x = 60;
            pos.y = (i*30)+70;

            if(getVF(question->tabRep[i]) == true)
                    aff->posBonneRep = pos.y;

            sprintf(phrase, "%s", getRep(question->tabRep[i]));
            aff->texte = TTF_RenderUTF8_Blended(aff->police, phrase, couleur);
            SDL_BlitSurface(aff->texte, NULL, aff->SurfacePlateau, &pos);
            SDL_FreeSurface(aff->texte);
        }

    free(phrase);
    TTF_CloseFont(aff->police);
}
void affichageSurfaceScore(AffichageSdl *aff, const Jeu *jeu)
{
    int nbJou = jeu->nbrJ;
    int tailleY = aff->tailleYEcran;
    int jouActu = jeu->joueurActu;
    SDL_Color couleur = {0,0,0};
    SDL_Rect pos;
    int i;
    double mult;
    char *score = malloc(sizeof(char)*128);
    SDL_FillRect(aff->SurfaceScore,NULL,SDL_MapRGB(aff->SurfaceScore->format, 255,255,255));

    for(i=0;i<nbJou; i++)
    {
        switch(i)
        {
            case 0:
                couleur.r = 255;
                couleur.g = 0;
                couleur.b = 0;
                break;
            case 1:
                couleur.r = 0;
                couleur.g = 0;
                couleur.b = 255;
                break;
            case 2:
                couleur.r = 0;
                couleur.g = 255;
                couleur.b = 0;
                break;
            case 3:
                couleur.r = 250;
                couleur.g = 200;
                couleur.b = 0;
                break;

        }
        if(i == jouActu)
        {
            aff->police = TTF_OpenFont("data/police.ttf", 30);
            mult = 1.4;
        }
        else
        {
            aff->police = TTF_OpenFont("data/police.ttf", 20);
            mult = 1;
        }
        TTF_SetFontStyle(aff->police, TTF_STYLE_UNDERLINE | TTF_STYLE_BOLD);
        pos.x = 50;
        pos.y = i*(tailleY/nbJou)+10*mult;
        sprintf(score, "%s :", get_pseudo(jeu->jou[i]));
        aff->texte = TTF_RenderUTF8_Blended(aff->police, score, couleur);
        SDL_BlitSurface(aff->texte, NULL, aff->SurfaceScore, &pos);
        SDL_FreeSurface(aff->texte);

        TTF_SetFontStyle(aff->police, TTF_STYLE_NORMAL);
        pos.x = 10;
        pos.y = i*(tailleY/nbJou)+30*mult;
        sprintf(score, "Position: %d", getPosition(jeu->jou[i]));
        aff->texte = TTF_RenderUTF8_Blended(aff->police, score, couleur);
        SDL_BlitSurface(aff->texte, NULL, aff->SurfaceScore, &pos);
        SDL_FreeSurface(aff->texte);

        pos.x = 10;
        pos.y = i*(tailleY/nbJou)+50*mult;
        sprintf(score, "Score: %d / 26", getScore(jeu->jou[i]));
        aff->texte = TTF_RenderUTF8_Blended(aff->police, score, couleur);
        SDL_BlitSurface(aff->texte, NULL, aff->SurfaceScore, &pos);
        SDL_FreeSurface(aff->texte);

        pos.x = 10;
        pos.y = i*(tailleY/nbJou)+70*mult;
        sprintf(score, "Niveau: %d / %d", getNiveau(jeu->jou[i])+1, jeu->nombrePlateaux);
        aff->texte = TTF_RenderUTF8_Blended(aff->police, score, couleur);
        SDL_BlitSurface(aff->texte, NULL, aff->SurfaceScore, &pos);
        SDL_FreeSurface(aff->texte);

        if(i == jouActu)
        {
            pos.x = 210;
            pos.y = (i*tailleY/nbJou)+70;

            SDL_BlitSurface(aff->imagesCarte[0], NULL, aff->SurfaceScore, &pos);
        }

        TTF_CloseFont(aff->police);
    }
    free(score);

}
void affichageMainJoueur(AffichageSdl *aff, const Jeu *jeu)
{
    int i;
    SDL_Color couleur = {0,0,0};
    SDL_Rect pos;
    int tailleX = aff->tailleXEcran;
    int tailleY = aff->tailleYEcran;
    int nbMain = jeu->jou[jeu->joueurActu]->nbMainJoueur;
    char *phrase = malloc(sizeof(char)*128);
    aff->police = TTF_OpenFont("data/police.ttf", 10);

    for(i=0;i<nbMain;i++)
    {
        pos.x = tailleX - tailleY -100;
        pos.y = (tailleY/4)*i+4;
        SDL_BlitSurface(aff->imagesCarteMini[(jeu->jou[jeu->joueurActu]->mainJoueur[i]->genre)-1], NULL, aff->SurfaceScore, &pos);

        pos.x = tailleX - tailleY -100;
        pos.y = (tailleY/4)*i+8;
        sprintf(phrase, "%s :", jeu->jou[jeu->joueurActu]->mainJoueur[i]->nom);
        aff->texte = TTF_RenderUTF8_Blended(aff->police, phrase, couleur);
        SDL_BlitSurface(aff->texte, NULL, aff->SurfaceScore, &pos);
        SDL_FreeSurface(aff->texte);

    }
    free(phrase);
    TTF_CloseFont(aff->police);
}
void affichageTousJoueurs(const AffichageSdl *aff, const Jeu *jeu)
{
    SDL_Rect pos;
    int tailleCase = aff->tailleCase;
    int nbJou = jeu->nbrJ;
    int i,j,k;
    int posJou;
    SDL_Surface *image = NULL;
    int temp[6][6] = {{0,1,2,3,4,5},{19,20,21,22,23,6},{18,31,32,33,24,7},{17,30,35,34,25,8},{16,29,28,27,26,9},{15,14,13,12,11,10}};


    for(i=0;i<nbJou;i++)
    {
        posJou = getPosition(jeu->jou[i]);
        image = affichageSurfaceJoueur(aff, jeu->jou[i]);

        for(j=0;j<6;j++)
        {
            for(k=0;k<6;k++)
            {
                if(temp[j][k] == posJou)
                {
                    pos.x = (k*tailleCase)+(tailleCase/2)-(i*10);
                    pos.y = (j*tailleCase)+(tailleCase/2)-(i*10);
                }
            }
        }
        SDL_BlitSurface(image, NULL, aff->SurfacePlateau, &pos);
    }
}
SDL_Surface * affichageSurfaceJoueur(const AffichageSdl *aff, const Joueur *jou)
{
    switch(jou->id)
    {
        case 1:
            return aff->imagesPion[0];
            break;

        case 2:
            return aff->imagesPion[1];
            break;

        case 3:
            return aff->imagesPion[2];
            break;

        case 4:
            return aff->imagesPion[3];
            break;

        default:
            return aff->imagesPion[0];
            break;
    }
}
void affichageSurfacePlateau(const AffichageSdl *aff, const Jeu *jeu)
{
    SDL_Rect pos;
    SDL_FillRect(aff->SurfacePlateau,NULL,SDL_MapRGB(aff->SurfacePlateau->format, 255,0,0));
    pos.x = 0;
    pos.y = 0;
    SDL_BlitSurface(aff->surfaceCases, NULL, aff->SurfacePlateau, &pos);
}

